// TarEntry.cs
//
// Copyright (C) 2001 Mike Krueger
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// Linking this library statically or dynamically with other modules is
// making a combined work based on this library.  Thus, the terms and
// conditions of the GNU General Public License cover the whole
// combination.
// 
// As a special exception, the copyright holders of this library give you
// permission to link this library with independent modules to produce an
// executable, regardless of the license terms of these independent
// modules, and to copy and distribute the resulting executable under
// terms of your choice, provided that you also meet, for each linked
// independent module, the terms and conditions of the license of that
// module.  An independent module is a module which is not derived from
// or based on this library.  If you modify this library, you may extend
// this exception to your version of the library, but you are not
// obligated to do so.  If you do not wish to do so, delete this
// exception statement from your version.

using System;
using System.IO;

namespace ICSharpCode.SharpZipLib.Tar
{
    /// <summary>
    /// This class represents an entry in a Tar archive. It consists
    /// of the entry's _header, as well as the entry's File. Entries
    /// can be instantiated in one of three ways, depending on how
    /// they are to be used.
    /// <p>
    /// TarEntries that are created from the _header bytes read from
    /// an archive are instantiated with the TarEntry( byte[] )
    /// constructor. These entries will be used when extracting from
    /// or listing the contents of an archive. These entries have their
    /// _header filled in using the _header bytes. They also set the File
    /// to null, since they reference an archive entry not a _file.</p>
    /// <p>
    /// TarEntries that are created from files that are to be written
    /// into an archive are instantiated with the CreateEntryFromFile(string)
    /// pseudo constructor. These entries have their _header filled in using
    /// the File's information. They also keep a reference to the File
    /// for convenience when writing entries.</p>
    /// <p>
    /// Finally, TarEntries can be constructed from nothing but a name.
    /// This allows the programmer to construct the entry by hand, for
    /// instance when only an InputStream is available for writing to
    /// the archive, and the _header information is constructed from
    /// other information. In this case the _header fields are set to
    /// defaults and the File is set to null.</p>
    /// <see cref="TarHeader"/>
    /// </summary>
    public class TarEntry
    {
        #region Constructors

        /// <summary>
        /// Initialise a default instance of <see cref="TarEntry"/>.
        /// </summary>
        private TarEntry()
        {
            _header = new TarHeader();
        }

        /// <summary>
        /// Construct an entry from an archive's _header bytes. File is set
        /// to null.
        /// </summary>
        /// <param name = "headerBuffer">
        /// The _header bytes from a tar archive entry.
        /// </param>
        public TarEntry(byte[] headerBuffer)
        {
            _header = new TarHeader();
            _header.ParseBuffer(headerBuffer);
        }

        /// <summary>
        /// Construct a TarEntry using the <paramref name="header">_header</paramref> provided
        /// </summary>
        /// <param name="header">Header details for entry</param>
        public TarEntry(TarHeader header)
        {
            if (header == null)
            {
                throw new ArgumentNullException("header");
            }

            _header = (TarHeader) header.Clone();
        }

        #endregion

        /// <summary>
        /// Get this entry's _header.
        /// </summary>
        /// <returns>
        /// This entry's TarHeader.
        /// </returns>
        public TarHeader TarHeader
        {
            get { return _header; }
        }

        /// <summary>
        /// Get/Set this entry's name.
        /// </summary>
        public string Name
        {
            get { return _header.Name; }
            set { _header.Name = value; }
        }

        /// <summary>
        /// Get/set this entry's user id.
        /// </summary>
        public int UserId
        {
            get { return _header.UserId; }
            set { _header.UserId = value; }
        }

        /// <summary>
        /// Get/set this entry's group id.
        /// </summary>
        public int GroupId
        {
            get { return _header.GroupId; }
            set { _header.GroupId = value; }
        }

        /// <summary>
        /// Get/set this entry's user name.
        /// </summary>
        public string UserName
        {
            get { return _header.UserName; }
            set { _header.UserName = value; }
        }

        /// <summary>
        /// Get/set this entry's group name.
        /// </summary>
        public string GroupName
        {
            get { return _header.GroupName; }
            set { _header.GroupName = value; }
        }

        /// <summary>
        /// Get/Set the modification time for this entry
        /// </summary>
        public DateTime ModTime
        {
            get { return _header.ModTime; }
            set { _header.ModTime = value; }
        }

        /// <summary>
        /// Get this entry's _file.
        /// </summary>
        /// <returns>
        /// This entry's _file.
        /// </returns>
        public string File
        {
            get { return _file; }
        }

        /// <summary>
        /// Get/set this entry's recorded _file size.
        /// </summary>
        public long Size
        {
            get { return _header.Size; }
            set { _header.Size = value; }
        }

        /// <summary>
        /// Return true if this entry represents a directory, false otherwise
        /// </summary>
        /// <returns>
        /// True if this entry is a directory.
        /// </returns>
        public bool IsDirectory
        {
            get
            {
                if (_file != null)
                {
                    return Directory.Exists(_file);
                }

                if (_header != null)
                {
                    if ((_header.TypeFlag == TarHeader.LF_DIR) || Name.EndsWith("/"))
                    {
                        return true;
                    }
                }
                return false;
            }
        }

        /// <summary>
        /// Clone this tar entry.
        /// </summary>
        /// <returns>Returns a clone of this entry.</returns>
        public object Clone()
        {
            var entry = new TarEntry{_file = _file, _header = ((TarHeader) _header.Clone()), Name = Name};
            return entry;
        }

        /// <summary>
        /// Construct an entry with only a <paramref name="name">name</paramref>.
        /// This allows the programmer to construct the entry's _header "by hand". 
        /// </summary>
        /// <param name="name">The name to use for the entry</param>
        /// <returns>Returns the newly created <see cref="TarEntry"/></returns>
        public static TarEntry CreateTarEntry(string name)
        {
            var entry = new TarEntry();
            NameTarHeader(entry._header, name);
            return entry;
        }

        /// <summary>
        /// Construct an entry for a _file. File is set to _file, and the
        /// _header is constructed from information from the _file.
        /// </summary>
        /// <param name = "fileName">The _file name that the entry represents.</param>
        /// <returns>Returns the newly created <see cref="TarEntry"/></returns>
        public static TarEntry CreateEntryFromFile(string fileName)
        {
            var entry = new TarEntry();
            entry.GetFileTarHeader(entry._header, fileName);
            return entry;
        }

        /// <summary>
        /// Determine if the two entries are equal. Equality is determined
        /// by the _header names being equal.
        /// </summary>
        /// <param name="obj">The <see cref="object"/> to compare with the current Object.</param>
        /// <returns>
        /// True if the entries are equal; false if not.
        /// </returns>
        public override bool Equals(object obj)
        {
            var localEntry = obj as TarEntry;

            if (localEntry != null)
            {
                return Name.Equals(localEntry.Name);
            }
            return false;
        }

        /// <summary>
        /// Derive a Hash value for the current <see cref="object"/>
        /// </summary>
        /// <returns>A Hash code for the current <see cref="object"/></returns>
        public override int GetHashCode()
        {
            return Name.GetHashCode();
        }

        /// <summary>
        /// Determine if the given entry is a descendant of this entry.
        /// Descendancy is determined by the name of the descendant
        /// starting with this entry's name.
        /// </summary>
        /// <param name = "toTest">
        /// Entry to be checked as a descendent of this.
        /// </param>
        /// <returns>
        /// True if entry is a descendant of this.
        /// </returns>
        public bool IsDescendent(TarEntry toTest)
        {
            if (toTest == null)
            {
                throw new ArgumentNullException("toTest");
            }

            return toTest.Name.StartsWith(Name);
        }

        /// <summary>
        /// Convenience method to set this entry's group and user ids.
        /// </summary>
        /// <param name="userId">
        /// This entry's new user id.
        /// </param>
        /// <param name="groupId">
        /// This entry's new group id.
        /// </param>
        public void SetIds(int userId, int groupId)
        {
            UserId = userId;
            GroupId = groupId;
        }

        /// <summary>
        /// Convenience method to set this entry's group and user names.
        /// </summary>
        /// <param name="userName">
        /// This entry's new user name.
        /// </param>
        /// <param name="groupName">
        /// This entry's new group name.
        /// </param>
        public void SetNames(string userName, string groupName)
        {
            UserName = userName;
            GroupName = groupName;
        }

        /// <summary>
        /// Fill in a TarHeader with information from a File.
        /// </summary>
        /// <param name="header">
        /// The TarHeader to fill in.
        /// </param>
        /// <param name="file">
        /// The _file from which to get the _header information.
        /// </param>
        public void GetFileTarHeader(TarHeader header, string file)
        {
            if (header == null)
            {
                throw new ArgumentNullException("header");
            }

            if (file == null)
            {
                throw new ArgumentNullException("file");
            }

            _file = file;

            // bugfix from torhovl from #D forum:
            var name = file;

            // 23-Jan-2004 GnuTar allows device names in path where the name is not local to the current directory
            if (name.IndexOf(Environment.CurrentDirectory) == 0)
            {
                name = name.Substring(Environment.CurrentDirectory.Length);
            }
/*
			if (Path.DirectorySeparatorChar == '\\') 
			{
				// check if the OS is Windows
				// Strip off drive letters!
				if (name.Length > 2) 
				{
					char ch1 = name[0];
					char ch2 = name[1];
					
					if (ch2 == ':' && Char.IsLetter(ch1)) 
					{
						name = name.Substring(2);
					}
				}
			}
*/

            name = name.Replace(Path.DirectorySeparatorChar, '/');

            // No absolute pathnames
            // Windows (and Posix?) paths can start with UNC style "\\NetworkDrive\",
            // so we loop on starting /'s.
            while (name.StartsWith("/"))
            {
                name = name.Substring(1);
            }

            header.LinkName = String.Empty;
            header.Name = name;

            if (Directory.Exists(file))
            {
                header.Mode = 1003; // Magic number for security access for a UNIX filesystem
                header.TypeFlag = TarHeader.LF_DIR;
                if ((header.Name.Length == 0) || header.Name[header.Name.Length - 1] != '/')
                {
                    header.Name = header.Name + "/";
                }

                header.Size = 0;
            }
            else
            {
                header.Mode = 33216; // Magic number for security access for a UNIX filesystem
                header.TypeFlag = TarHeader.LF_NORMAL;
                header.Size = new FileInfo(file.Replace('/', Path.DirectorySeparatorChar)).Length;
            }

            header.ModTime =
                System.IO.File.GetLastWriteTime(file.Replace('/', Path.DirectorySeparatorChar)).ToUniversalTime();
            header.DevMajor = 0;
            header.DevMinor = 0;
        }

        /// <summary>
        /// Get entries for all files present in this entries directory.
        /// If this entry doesnt represent a directory zero entries are returned.
        /// </summary>
        /// <returns>
        /// An array of TarEntry's for this entry's children.
        /// </returns>
        public TarEntry[] GetDirectoryEntries()
        {
#if (!SILVERLIGHT)
            if ((_file == null) || !Directory.Exists(_file))
            {
                return new TarEntry[0];
            }

            var list = Directory.GetFileSystemEntries(_file);
            var result = new TarEntry[list.Length];

            for (var i = 0; i < list.Length; ++i)
            {
                result[i] = CreateEntryFromFile(list[i]);
            }

            return result;
#else
        	return null;
#endif
        }

        /// <summary>
        /// Write an entry's _header information to a _header buffer.
        /// </summary>
        /// <param name = "outBuffer">
        /// The tar entry _header buffer to fill in.
        /// </param>
        public void WriteEntryHeader(byte[] outBuffer)
        {
            _header.WriteHeader(outBuffer);
        }

        /// <summary>
        /// Convenience method that will modify an entry's name directly
        /// in place in an entry _header buffer byte array.
        /// </summary>
        /// <param name="buffer">
        /// The buffer containing the entry _header to modify.
        /// </param>
        /// <param name="newName">
        /// The new name to place into the _header buffer.
        /// </param>
        public static void AdjustEntryName(byte[] buffer, string newName)
        {
            var offset = 0;
            TarHeader.GetNameBytes(newName, buffer, offset, TarHeader.NAMELEN);
        }

        /// <summary>
        /// Fill in a TarHeader given only the entry's name.
        /// </summary>
        /// <param name="header">
        /// The TarHeader to fill in.
        /// </param>
        /// <param name="name">
        /// The tar entry name.
        /// </param>
        public static void NameTarHeader(TarHeader header, string name)
        {
            if (header == null)
            {
                throw new ArgumentNullException("header");
            }

            if (name == null)
            {
                throw new ArgumentNullException("name");
            }

            var isDir = name.EndsWith("/");

            header.Name = name;
            header.Mode = isDir ? 1003 : 33216;
            header.UserId = 0;
            header.GroupId = 0;
            header.Size = 0;

            header.ModTime = DateTime.UtcNow;

            header.TypeFlag = isDir ? TarHeader.LF_DIR : TarHeader.LF_NORMAL;

            header.LinkName = String.Empty;
            header.UserName = String.Empty;
            header.GroupName = String.Empty;

            header.DevMajor = 0;
            header.DevMinor = 0;
        }

        #region Instance Fields

        /// <summary>
        /// The name of the _file this entry represents or null if the entry is not based on a _file.
        /// </summary>
        private string _file;

        /// <summary>
        /// The entry's _header information.
        /// </summary>
        private TarHeader _header;

        #endregion
    }
}

/* The original Java file had this header:
	*
	** Authored by Timothy Gerard Endres
	** <mailto:time@gjt.org>  <http://www.trustice.com>
	**
	** This work has been placed into the public domain.
	** You may use this work in any way and for any purpose you wish.
	**
	** THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY OF ANY KIND,
	** NOT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY. THE AUTHOR
	** OF THIS SOFTWARE, ASSUMES _NO_ RESPONSIBILITY FOR ANY
	** CONSEQUENCE RESULTING FROM THE USE, MODIFICATION, OR
	** REDISTRIBUTION OF THIS SOFTWARE.
	**
	*/